{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import sys\n",
    "current_directory = os.getcwd()\n",
    "upper_directory = os.path.abspath(os.path.join(current_directory, \"..\"))\n",
    "sys.path.append(upper_directory)\n",
    "\n",
    "\n",
    "## ================================================================= ##\n",
    "\n",
    "import numpy as np\n",
    "import cvxpy as cp\n",
    "from cvxpy import quad_form\n",
    "import numpy as np\n",
    "import time \n",
    "import tqdm\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from sklearn.decomposition import KernelPCA\n",
    "from scipy.linalg import khatri_rao\n",
    "\n",
    "# Set the random seed\n",
    "np.random.seed(2025)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load data\n",
    "data_save_path = '../data/L96_data_dim40'\n",
    "N = 30 # Increase this to use more training data. More accuracte but risk of OOM.\n",
    "train_idx = np.random.choice(500, N, replace=False)\n",
    "train_seq_state = np.load(data_save_path + '/train_seq_state.npy', mmap_mode='r')[train_idx, 500:, ...]\n",
    "train_seq_obs = np.load(data_save_path + '/train_seq_obs.npy', mmap_mode='r')[train_idx, 500:, ...]\n",
    "train_seq_hist = np.load(data_save_path + '/train_seq_hist.npy', mmap_mode='r')[train_idx, 500:, ...]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### $C_{S^+|S}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] Number of samples:  45000\n"
     ]
    }
   ],
   "source": [
    "N, T,_ = train_seq_state.shape\n",
    "print(\"[INFO] Number of samples: \", N*T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# state_feature_transform = KernelPCA(n_components=80, kernel='matern2.5', fit_inverse_transform=True)\n",
    "d_s = 80 # Number of features \n",
    "\n",
    "state_feature_transform = KernelPCA(n_components=d_s, kernel='rbf', fit_inverse_transform=True)\n",
    "X = np.array([train_seq_state[i,j] for i in range(N) for j in range(0,T-1)])\n",
    "X_next = np.array([train_seq_state[i,j] for i in range(N) for j in range(1,T)])\n",
    "\n",
    "state_mean = np.mean(X, axis=0)\n",
    "state_std = np.std(X, axis=0)\n",
    "\n",
    "X = (X - state_mean) / state_std\n",
    "X_next = (X_next - state_mean) / state_std\n",
    "\n",
    "X_features = state_feature_transform.fit_transform(X=X)\n",
    "X_next_features = state_feature_transform.transform(X_next)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "K_X = X_features.T@X_features\n",
    "K_X_regularized = K_X + 1e-3 * np.eye(K_X.shape[0])\n",
    "K_X_INV = np.linalg.solve(K_X_regularized, X_next_features.T)\n",
    "C_fwd = K_X_INV @ X_features "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### B and Q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "B = np.cov(X_features, rowvar=False)\n",
    "B = np.linalg.pinv(B+1e-3*np.eye(B.shape[0]))\n",
    "B = (B + B.T) / 2\n",
    "\n",
    "fwd_error = X_next_features - (C_fwd @ X_features.T).T\n",
    "Q = np.cov(fwd_error, rowvar=False)\n",
    "Q = np.linalg.pinv(Q+1e-3*np.eye(Q.shape[0]))\n",
    "Q = (Q + Q.T) / 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z_b = X_features.mean(axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### $C_{S|OH}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "obs_feature_transform = KernelPCA(n_components=32, kernel='rbf')\n",
    "hist_feature_transform = KernelPCA(n_components=32, kernel='rbf')\n",
    "\n",
    "O = np.array([train_seq_obs[i,j] for i in range(N) for j in range(0,T-1)])\n",
    "H = np.array([train_seq_hist[i,j].flatten() for i in range(N) for j in range(0,T-1)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "obs_mean = np.mean(O, axis=0)\n",
    "obs_std = np.std(O, axis=0)\n",
    "\n",
    "O = (O - obs_mean) / obs_std\n",
    "O_features = obs_feature_transform.fit_transform(X=O)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "hist_mean = np.mean(H, axis=0)\n",
    "hist_std = np.std(H, axis=0)\n",
    "\n",
    "H = (H - hist_mean) / hist_std\n",
    "H_features = hist_feature_transform.fit_transform(X=H)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "OH = khatri_rao(O_features.T, H_features.T).T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "K_OH = OH@OH.T\n",
    "K_OH_regularized = K_OH + 1e-3 * np.eye(K_OH.shape[0])\n",
    "K_OH_INV = np.linalg.solve(K_OH_regularized, X_features)\n",
    "C_Inv = K_OH_INV.T @ OH"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### R"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "obs_error = X_features - (C_Inv @ OH.T).T\n",
    "R = np.cov(obs_error, rowvar=False)\n",
    "R = np.linalg.pinv(R + 1e-3*np.eye(R.shape[0]))\n",
    "\n",
    "# Symmetrize R\n",
    "R = (R + R.T) / 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Forward model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "class phi_S:\n",
    "    def __init__(self, state_feature_transform, state_mean, state_std) -> None:\n",
    "        self.state_feature_transform = state_feature_transform\n",
    "        self.state_mean = state_mean\n",
    "        self.state_std = state_std\n",
    "        self.hidden_dims = [state_feature_transform.n_components]\n",
    "        \n",
    "    def __call__(self, x):\n",
    "        try:\n",
    "            x_feature = self.state_feature_transform.transform((x - self.state_mean) / self.state_std)\n",
    "        except:\n",
    "            x = x[None,:]\n",
    "            x_feature = self.state_feature_transform.transform((x - self.state_mean) / self.state_std)\n",
    "        return x_feature\n",
    "\n",
    "class phi_inv_S:\n",
    "    def __init__(self, state_feature_transform, state_mean, state_std) -> None:\n",
    "        self.state_feature_transform = state_feature_transform\n",
    "        self.state_mean = state_mean\n",
    "        self.state_std = state_std\n",
    "        self.hidden_dim = [state_feature_transform.n_components]\n",
    "        \n",
    "    def __call__(self, z):\n",
    "        try:\n",
    "            x = self.state_feature_transform.inverse_transform(z) * self.state_std + self.state_mean\n",
    "        except:\n",
    "            z = z[None,:]\n",
    "            x = self.state_feature_transform.inverse_transform(z) * self.state_std + self.state_mean\n",
    "        return x\n",
    "\n",
    "\n",
    "class forward_model:\n",
    "    def __init__(self, C_fwd, phi_S, phi_inv_S) -> None:\n",
    "        self.state_feature_transform = state_feature_transform\n",
    "        self.C_fwd = C_fwd\n",
    "        self.phi_S = phi_S\n",
    "        self.phi_inv_S = phi_inv_S\n",
    "    \n",
    "    def __call__(self, x):\n",
    "        x_feature = self.phi_S(x)\n",
    "        return (self.C_forward @ x_feature.T).T\n",
    "    \n",
    "\n",
    "fwd_model = forward_model(C_fwd, \n",
    "                          phi_S(state_feature_transform, state_mean, state_std), \n",
    "                          phi_inv_S(state_feature_transform, state_mean, state_std))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Inv Obs Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "class inverse_model:\n",
    "    def __init__(self, C_Inv, phi_S, phi_inv_S, \n",
    "                 obs_feature_transform, obs_mean, obs_std,\n",
    "                 hist_feature_transform, hist_mean, hist_std) -> None:\n",
    "        self.obs_feature_transform = obs_feature_transform\n",
    "        self.hist_feature_transform = hist_feature_transform\n",
    "        self.C_Inv = C_Inv\n",
    "        self.phi_S = phi_S\n",
    "        self.phi_inv_S = phi_inv_S\n",
    "        self.obs_mean = obs_mean\n",
    "        self.obs_std = obs_std\n",
    "        self.hist_mean = hist_mean\n",
    "        self.hist_std = hist_std\n",
    "    \n",
    "    def __call__(self, o, h):\n",
    "        o_feature = self.obs_feature_transform.transform((o - self.obs_mean) / self.obs_std)\n",
    "        h_feature = self.hist_feature_transform.transform((h - self.hist_mean) / self.hist_std)\n",
    "        oh_feature = khatri_rao(o_feature.T, h_feature.T).T\n",
    "        x_feature = (self.C_Inv @ oh_feature.T).T\n",
    "        return x_feature\n",
    "\n",
    "\n",
    "inv_obs_model = inverse_model(C_Inv, \n",
    "                              phi_S(state_feature_transform, state_mean, state_std), \n",
    "                              phi_inv_S(state_feature_transform, state_mean, state_std),\n",
    "                              obs_feature_transform, obs_mean, obs_std,\n",
    "                              hist_feature_transform, hist_mean, hist_std)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define 4D-Var Solver"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def QP_solver(z_b, seq_z, F, B, R, Q, T):\n",
    "    \"\"\"\n",
    "    Quadratic Programming Solver\n",
    "    \"\"\"\n",
    "    constraints = []\n",
    "    state_dim = z_b.shape[0]\n",
    "    pred_seq_z = cp.Variable((T, state_dim))\n",
    "    cost = 0 \n",
    "    \n",
    "    penalty = np.linspace(0.1, 1, T-1)[::-1]\n",
    "    for t in range(T):\n",
    "        if t == 0:\n",
    "            cost += quad_form(pred_seq_z[t] - z_b, B)\n",
    "            cost += quad_form(pred_seq_z[t] - seq_z[t], R)\n",
    "            \n",
    "        else:   \n",
    "            cost += quad_form(pred_seq_z[t] - seq_z[t], R)\n",
    "            cost += quad_form(pred_seq_z[t] - F@pred_seq_z[t-1], penalty[t-1]*Q)\n",
    "    objective = cp.Minimize(cost)\n",
    "    prob = cp.Problem(objective, constraints)\n",
    "    prob.solve() \n",
    "    # Get the final solution\n",
    "    analyzed_traj_states = pred_seq_z.value\n",
    "    \n",
    "    return analyzed_traj_states\n",
    "\n",
    "class Tensor_Var:\n",
    "    def __init__(self, forward_model, observation_model, n_state, n_obs, B, R, Q) -> None:\n",
    "        self.forward_model = forward_model\n",
    "        self.observation_model = observation_model\n",
    "        self.n_state = n_state\n",
    "        self.n_obs = n_obs\n",
    "        self.n_hidden = self.forward_model.phi_S.hidden_dims[-1]\n",
    "\n",
    "        self.B = B\n",
    "        self.R = R\n",
    "        self.Q = Q\n",
    "        \n",
    "    def perform_4DVar(self, \n",
    "                           seq_obs:np.array, \n",
    "                           seq_hist:np.array,\n",
    "                           z_b:np.array=None, \n",
    "                           assimilation_window:int=3, \n",
    "                           T:int=500):\n",
    "        \n",
    "        B = self.B\n",
    "        R = self.R\n",
    "        Q = self.Q\n",
    "\n",
    "        F = self.forward_model.C_fwd\n",
    "\n",
    "        horizon_traj_estimation = []\n",
    "        start_time = time.time()\n",
    "        for start in tqdm.tqdm(range(0, T, assimilation_window)):\n",
    "            end = min(start + assimilation_window, T)\n",
    "            # project the phi_o, phi_h to phi_s\n",
    "            hist = seq_hist[start:end]\n",
    "            hist = hist.reshape(hist.shape[0], -1)\n",
    "            obs = seq_obs[start:end]\n",
    "            seq_z = self.observation_model(obs, hist)\n",
    "\n",
    "            result = QP_solver(z_b=z_b, \n",
    "                                seq_z=seq_z, \n",
    "                                F=F, \n",
    "                                B=B, \n",
    "                                Q=Q, \n",
    "                                R=R, \n",
    "                                T=assimilation_window)\n",
    "\n",
    "            optimal_traj = self.forward_model.phi_inv_S(result)\n",
    "            horizon_traj_estimation.extend(optimal_traj)\n",
    "        end_time = time.time()\n",
    "        evaluation_time = end_time - start_time\n",
    "        return horizon_traj_estimation, evaluation_time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Perform DA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "del train_seq_hist\n",
    "del train_seq_obs\n",
    "del train_seq_state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set the parameters\n",
    "n_state = 40\n",
    "n_obs = int(n_state * 0.2)\n",
    "\n",
    "ass_w = 5 # assimilation window \n",
    "ass_T = ass_w * 20\n",
    "\n",
    "num_mc = 10 # number of repeated experiments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "DA_Tensor_Var = Tensor_Var(fwd_model, \n",
    "                           inv_obs_model, \n",
    "                           n_state=n_state,\n",
    "                           n_obs=n_obs,\n",
    "                           B=B,\n",
    "                           R=R, \n",
    "                           Q=Q\n",
    "                          )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load data\n",
    "data_save_path = '../data/L96_data_dim40'\n",
    "test_seq_state = np.load(data_save_path + '/test_seq_state.npy', mmap_mode='r')[:num_mc, 500:, ...]\n",
    "test_seq_obs = np.load(data_save_path + '/test_seq_obs.npy', mmap_mode='r')[:num_mc, 500:, ...]\n",
    "test_seq_hist = np.load(data_save_path + '/test_seq_hist.npy', mmap_mode='r')[:num_mc, 500:, ...]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] Assimilation Window Length: 5\n",
      "[INFO] Traj Length: 100\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "DA Evaulation:   0%|          | 0/10 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(80,)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 20/20 [00:02<00:00,  8.92it/s]\n",
      "DA Evaulation:  10%|█         | 1/10 [00:02<00:20,  2.26s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] 0th traj Estimation Error: 0.11605942657571144\n",
      "(80,)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 20/20 [00:02<00:00,  8.80it/s]\n",
      "DA Evaulation:  20%|██        | 2/10 [00:04<00:18,  2.28s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] 1th traj Estimation Error: 0.12087261308946612\n",
      "(80,)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 20/20 [00:02<00:00,  9.24it/s]\n",
      "DA Evaulation:  30%|███       | 3/10 [00:06<00:15,  2.23s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] 2th traj Estimation Error: 0.11228565399452362\n",
      "(80,)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 20/20 [00:02<00:00,  9.15it/s]\n",
      "DA Evaulation:  40%|████      | 4/10 [00:08<00:13,  2.22s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] 3th traj Estimation Error: 0.11704251945206054\n",
      "(80,)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 20/20 [00:02<00:00,  9.20it/s]\n",
      "DA Evaulation:  50%|█████     | 5/10 [00:11<00:11,  2.21s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] 4th traj Estimation Error: 0.11753664167825002\n",
      "(80,)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 20/20 [00:02<00:00,  9.08it/s]\n",
      "DA Evaulation:  60%|██████    | 6/10 [00:13<00:08,  2.21s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] 5th traj Estimation Error: 0.11836760354340545\n",
      "(80,)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 20/20 [00:02<00:00,  9.06it/s]\n",
      "DA Evaulation:  70%|███████   | 7/10 [00:15<00:06,  2.22s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] 6th traj Estimation Error: 0.1162434785082949\n",
      "(80,)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 20/20 [00:02<00:00,  9.13it/s]\n",
      "DA Evaulation:  80%|████████  | 8/10 [00:17<00:04,  2.21s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] 7th traj Estimation Error: 0.12480258689374775\n",
      "(80,)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 20/20 [00:02<00:00,  8.39it/s]\n",
      "DA Evaulation:  90%|█████████ | 9/10 [00:20<00:02,  2.28s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] 8th traj Estimation Error: 0.11707490024085114\n",
      "(80,)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 20/20 [00:02<00:00,  8.63it/s]\n",
      "DA Evaulation: 100%|██████████| 10/10 [00:22<00:00,  2.25s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] 9th traj Estimation Error: 0.10816736793324397\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x2400 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "error_list = np.zeros(num_mc)\n",
    "time_list = np.zeros(num_mc)\n",
    "max_value = test_seq_state.max()\n",
    "min_value = test_seq_state.min()\n",
    "print(\"[INFO] Assimilation Window Length: {}\".format(ass_w))\n",
    "print(\"[INFO] Traj Length: {}\".format(ass_T))\n",
    "for i in tqdm.tqdm(range(num_mc), desc=\"DA Evaulation\"):\n",
    "    traj_true = test_seq_state[i, :ass_T]\n",
    "    traj_estimation, eval_time = DA_Tensor_Var.perform_4DVar(test_seq_obs[i], \n",
    "                                                             seq_hist=test_seq_hist[i], \n",
    "                                                             z_b=z_b, \n",
    "                                                             assimilation_window=ass_w, \n",
    "                                                             T=ass_T)\n",
    "    rmse = np.sqrt( np.mean( (np.array(traj_estimation) - traj_true)**2) )/(max_value-min_value)\n",
    "    error_list[i] = rmse\n",
    "    time_list[i] = eval_time\n",
    "    print(\"[INFO] {}th traj Estimation Error: {}\".format(i,rmse))\n",
    "\n",
    "\n",
    "fig, ax = plt.subplots(3, 1, figsize=(10, 24))\n",
    "ax[0].imshow(np.array(traj_estimation).T)\n",
    "ax[0].set_title('Estimated Trajectory')\n",
    "ax[1].imshow(traj_true.T)\n",
    "ax[1].set_title('True Trajectory')\n",
    "cbar = ax[2].imshow(np.abs(np.array(traj_estimation).T - traj_true.T))\n",
    "plt.colorbar(cbar, ax=ax[2], shrink=0.8)\n",
    "ax[2].set_title('Error')\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "PODA",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
